package com.gjy.scala

object BasicGrammar {
  /**
   * Scala 是一种多范式编程语言，它结合了面向对象编程和函数式编程的特性。以下是一些 Scala 的基础语法：
   * 变量和常量：
   * val 用于定义不可变的常量。
   * var 用于定义可变的变量。
   * 数据类型：
   * Scala 有丰富的数据类型，包括基本数据类型（如 Int, Double, Char 等）和复合数据类型（如 List, Map, Tuple 等）。
   * 函数定义：
   * 使用 def 关键字定义函数。
   * 函数可以有参数列表和返回类型。
   * 控制结构：
   * 包括条件语句（if-else）、循环语句（for, while）等。
   * 类和对象：
   * Scala 是面向对象的语言，支持类、对象、继承、多态等特性。
   * 模式匹配：
   * 类似于 switch 语句，但更强大和灵活。
   * 异常处理：
   * 使用 try-catch-finally 语句处理异常。
   * 类型推断：
   * Scala 编译器可以自动推断变量和表达式的类型。
   * 函数式编程特性：
   * 支持高阶函数、闭包、柯里化等函数式编程特性。
   * 集合操作：
   * Scala 提供了丰富的集合操作方法，如 map, filter, reduce 等。
   * 并发编程：
   * Scala 支持并发编程，提供了 Actor 模型和 Future 等并发编程工具。
   * 类型系统：
   * Scala 有强大的类型系统，支持泛型、类型参数化、类型推断等。
   * 注释：
   * Scala 支持单行注释 // 和多行注释 /*... */。
   * 包和导入：
   * 使用 package 关键字定义包，使用 import 关键字导入包和类。
   * 元组：
   * 元组是一个可以包含不同类型元素的固定大小的集合。
   * Option 和 Either：
   * Option 用于表示可能存在也可能不存在的值，Either 用于表示可能是两个值中的一个。
   * 隐式转换和参数：
   * Scala 支持隐式转换和隐式参数，可以在不修改现有代码的情况下扩展功能。
   * 特质（Traits）：
   * 特质类似于接口，但可以包含实现代码，支持多重继承。
   * 伴生对象和伴生类：
   * 伴生对象和伴生类可以共享相同的名称，并且可以访问对方的私有成员。
   * 应用程序入口点：
   * Scala 程序的入口点是 main 方法，通常定义在 object 中。
   *
   */
  def main(args: Array[String]): Unit = {

     // 1. 变量和常量
    val a = 1 // 常量
    var b = 2 // 变量
    print(a / b)
    print(Double.MinValue)
    //a=3 - 错误
    b = 3
    // 2. 数据类型
    //double
    val c = 1.0
    //string
    val d = 'a'
    val e =
      """
        |sadf
        |sdafasf
        |as
        |f
        |dsf
        |
        |f
        |sf
        |s
        |"""
    println(e)
    val m =
      """
        |sadf
        |sdafasf
        |as
        |f
        |dsf
        |
        |f
        |sf
        |s
        |""".stripMargin
    println(m)

    val f = "dasdfsadff" * 3
    //list
    val list = List(1, 2, 3)
    println("        list:" + list)
    println("   list.head:" + list.head)
    println("   list.tail:" + list.tail)
    println("list.isEmpty:" + list.isEmpty)
    println(" list.length:" + list.length)
    println("     list(1):" + list(1))

    val map = Map("a" -> 1, "b" -> 2)
    println(map)
    println(map("a"))
    println(map.get("a"))

    // 3. 函数定义
    def add(a: Int, b: Int): Int = {
      a + b
    }

    println(add(1, 2))

    // 4. 控制结构
    // 条件语句
    if (a > b) {
      println("a is greater than b")
    } else {
      println("a is less than or equal to b")
    }
    // 循环语句
    for (i <- 1 to 10) {
      println(i)
    }
    // 5. 类和对象
    class Person(name: String, age: Int) {
      def sayHello(): Unit = {
        println("Hello, my name is " + name + " and I am " + age + " years old")
      }
    }
    val person = new Person("Alice", 25)
    person.sayHello()

    // 6. 模式匹配
    val x = 1
    x match {
      case 1 => println("x is 1")
      case 2 => println("x is 2")
      case _ => println("x is something else")
    }
    // 定义一个case class
    case class Human(name: String, age: Int)
    // 创建一个Person实例
    val human = Human("Alice", 30)
    // 访问实例的字段
    println(human.name) // 输出: Alice
    println(human.age) // 输出: 30
    // 模式匹配
    human match {
      case Human("Alice", 30) => println("It's Alice!")
      case Human(name, age) => println(s"Hello, $name. You are $age years old.")
    }

    // 7. 异常处理
    try {
      val result = 10 / 0
      println(result)
    } catch {
      case e: ArithmeticException => println("Error: " + e.getMessage)
    } finally {
      println("Finally block executed")
    }
    // 8. 类型推断
    val y = 1.0
    println(y)

    // 9. 函数式编程特性
    val numbers = List(1, 2, 3, 4, 5)
    val squaredNumbers = numbers.map(x => x * x)
    println(squaredNumbers)

    // 10. 集合操作
    val filteredNumbers = numbers.filter(x => x % 2 == 0)
    println(filteredNumbers)

    // 11. 并发编程
    import scala.concurrent.ExecutionContext.Implicits.global
    import scala.concurrent.Future
    val future = Future {
      Thread.sleep(10)
      println("Hello from Future")
    }
    future.foreach(println)
    future.onComplete(_ => println("Future completed"))

    // 12. 类型系统
    def printType[T](x: T): Unit = {
      println(x.getClass)
    }

    printType(1)
    printType("Hello")

    // 13. 注释
    // 单行注释
    // 多行注释

    /*
    这是一个
    多行注释
     */


    //    // 14. 包和导入
    //    package com.example
    //    import scala.util.Random
    // 15. 元组
    val tuple = (1, "Hello", 3.14)
    println(tuple)
    // 16. Option 和 Either
    val maybeNumber: Option[Int] = Some(1)
    println(maybeNumber) // 输出: Some(1)
    val maybeString: Option[String] = None
    println(maybeString) // 输出: None

    val result: Either[String, Int] = Right(1)
    println(result) // 输出: Right(1)
    val error: Either[String, Int] = Left("Something went wrong")
    println(error) // 输出: Left(Something went wrong)


    // 17. 隐式转换和参数
    implicit val implicitValue: Int = 10

    def addWithImplicit(x: Int)(implicit y: Int): Int = {
      x + y
    }

    println(addWithImplicit(5))

    // 18. 特质（Traits）
    trait Printable {
      def print(): Unit
    }
    class Person2(name: String) extends Printable {
      def print(): Unit = {
        println("Person: " + name)
      }
    }
    val person3 = new Person2("Alice")
    person3.print()

  }

  // 19. 伴生对象和伴生类
  // 定义一个伴生类和伴生对象
  class MyClass private(val name: String) {
    // 私有构造函数，只能通过伴生对象创建实例

    protected def greet(): Unit = {
      println(s"Hello, $name!")
    }
  }

  object MyClass {
    // 伴生对象的apply方法，用于创建伴生类的实例
    def apply(name: String): MyClass = new MyClass(name)

    // 伴生对象的其他方法
    def info(): Unit = {
      println("This is the companion object of MyClass.")
    }

    def main(args: Array[String]): Unit = {
      info()
      val myInstance = MyClass("Alice")
      myInstance.greet()
    }
  }

  println("-------------------")

  // 20. 应用程序入口点
  object Main {
    def main(args: Array[String]): Unit = {
      println("Hello, world!")
    }
  }
}

